package com.haiyi.test.dtmoths;

import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
 /**
  * https://www.cnblogs.com/ivy-xu/p/12299174.html
  * @author fupc
  *
  */
public class RSADecrypt初 {
    public static Map<String, String> createKeyPair() throws NoSuchAlgorithmException {
        //创建秘钥对生成器
        KeyPairGenerator generator = KeyPairGenerator.getInstance("rsa");
        //初始化密钥对生成器
        generator.initialize(1024);
        //生成密钥对
        KeyPair keyPair = generator.generateKeyPair();
        //获取公钥私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //对象转String
        String publicKeyStr = new String(publicKey.getEncoded());
        String privateKeyStr = new String(privateKey.getEncoded());
        //公钥私钥存放map
        Map<String, String> keyMap = new HashMap<>();
        keyMap.put("publicKey", publicKeyStr);
        keyMap.put("privateKey", privateKeyStr);
        return keyMap;
    }
 
    /**
     * 获取公钥
     * @param publicKey
     * @return
     */
    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyFactory keyFactory = KeyFactory.getInstance("rsa");
        //X509编码
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey.getBytes());
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(x509EncodedKeySpec);
        return rsaPublicKey;
    }
 
    /**
     * 获取私钥
     * @param privateKey
     * @return
     */
    public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyFactory keyFactory = KeyFactory.getInstance("rsa");
        //PKCS#8编码
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey.getBytes());
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        return rsaPrivateKey;
    }
 
    /**
     * 公钥加密
     * @param src
     * @param publicKey
     * @return
     */
    public static byte[] publicEncrypt(String src, RSAPublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("rsa");
        cipher.init(Cipher.ENCRYPT_MODE,publicKey);
        //返回加密后的内容
        byte[] encryptedData = cipher.doFinal(src.getBytes());
        return encryptedData;
    }
 
    /**
     * 私钥解密
     * @param data
     * @param privateKey
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
    public static String privateDecrypt(byte[] data, RSAPrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("rsa");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        //返回解密后的内容
        byte[] result = cipher.doFinal(data);
        return new String(result);
    }
 
    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchPaddingException {
        Map<String,String> keyPair = createKeyPair();
        RSAPublicKey publicKey = getPublicKey(keyPair.get("publicKey"));
        RSAPrivateKey privateKey = getPrivateKey(keyPair.get("privateKey"));
        String str = "hello world";
        /**
         * 公钥加密，私钥解密
         */
        byte[] encryptedData = publicEncrypt(str,publicKey);
        String result = privateDecrypt(encryptedData, privateKey);
 
        /**
         * 私钥加密，公钥解密
         */
        byte[] encrypted = privateEncrypt(str, privateKey);
        String source = publicDecrypt(encrypted, publicKey);
 
    }
 
    /**
     * 私钥加密
     * @param src
     * @param privateKey
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
    public static byte[] privateEncrypt(String src, RSAPrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("rsa");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        //返回加密后的内容
        byte[] result = cipher.doFinal(src.getBytes());
        return result;
    }
 
    /**
     * 公钥解密
     * @param data
     * @param publicKey
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
    public static String publicDecrypt(byte[] data, RSAPublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("rsa");
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
      //返回解密后的内容
        byte[] result = cipher.doFinal(data);
        return new String(result);
    }
}